import pytest  # used for our unit tests
from workload import funcA

# unit tests

# --- Basic Test Cases ---

def test_zero():
    # Should return an empty string for 0
    codeflash_output = funcA(0) # 2.35μs -> 1.21μs (94.2% faster)

def test_one():
    # Should return "0" for 1
    codeflash_output = funcA(1) # 2.42μs -> 1.04μs (133% faster)

def test_small_number():
    # Should return "0 1 2 3 4" for 5
    codeflash_output = funcA(5) # 2.67μs -> 1.00μs (166% faster)

def test_typical_number():
    # Should return correct sequence for 10
    codeflash_output = funcA(10) # 3.17μs -> 902ns (251% faster)

def test_number_as_string_raises():
    # Should raise TypeError for non-integer input
    with pytest.raises(TypeError):
        funcA("10")

def test_float_input_raises():
    # Should raise TypeError for float input
    with pytest.raises(TypeError):
        funcA(5.5)

# --- Edge Test Cases ---

def test_negative_number():
    # Should return empty string for negative input
    codeflash_output = funcA(-1) # 2.20μs -> 1.08μs (104% faster)

def test_large_negative_number():
    # Should return empty string for large negative input
    codeflash_output = funcA(-1000) # 2.09μs -> 1.21μs (72.8% faster)

def test_number_exactly_1000():
    # Should return numbers from 0 to 999 (1000 numbers)
    codeflash_output = funcA(1000); result = codeflash_output # 88.9μs -> 1.11μs (7891% faster)
    expected = " ".join(str(i) for i in range(1000))

def test_number_above_1000():
    # Should cap at 1000, so 1005 returns 0..999
    codeflash_output = funcA(1005); result = codeflash_output # 77.3μs -> 1.16μs (6555% faster)
    expected = " ".join(str(i) for i in range(1000))

def test_number_just_below_1000():
    # Should return 0..998 for input 999
    codeflash_output = funcA(999); result = codeflash_output # 77.0μs -> 1.13μs (6699% faster)
    expected = " ".join(str(i) for i in range(999))

def test_number_is_none_raises():
    # Should raise TypeError for None input
    with pytest.raises(TypeError):
        funcA(None)

def test_bool_input():
    # Should treat True as 1, False as 0 (since bool is subclass of int in Python)
    codeflash_output = funcA(True) # 2.63μs -> 1.41μs (86.5% faster)
    codeflash_output = funcA(False) # 1.22μs -> 591ns (107% faster)

# --- Large Scale Test Cases ---

def test_large_number_999():
    # Should return 0..998 for input 999
    codeflash_output = funcA(999); result = codeflash_output # 78.1μs -> 1.22μs (6286% faster)
    expected = " ".join(str(i) for i in range(999))

def test_large_number_1000():
    # Should return 0..999 for input 1000
    codeflash_output = funcA(1000); result = codeflash_output # 77.1μs -> 1.07μs (7093% faster)
    expected = " ".join(str(i) for i in range(1000))

def test_large_number_1001():
    # Should cap at 1000, so returns 0..999
    codeflash_output = funcA(1001); result = codeflash_output # 77.2μs -> 1.08μs (7037% faster)
    expected = " ".join(str(i) for i in range(1000))

def test_performance_large_input():
    # Should not take too long for input 1000
    import time
    start = time.time()
    codeflash_output = funcA(1000); result = codeflash_output # 76.9μs -> 1.09μs (6935% faster)
    duration = time.time() - start

# --- Additional Edge Cases ---

def test_input_max_int():
    # Should cap at 1000 for very large integer input
    codeflash_output = funcA(10**9); result = codeflash_output # 76.8μs -> 1.09μs (6927% faster)
    expected = " ".join(str(i) for i in range(1000))

def test_input_min_int():
    # Should return empty string for very negative integer
    codeflash_output = funcA(-10**9); result = codeflash_output # 2.33μs -> 1.35μs (72.6% faster)

def test_input_is_list_raises():
    # Should raise TypeError for list input
    with pytest.raises(TypeError):
        funcA([1,2,3])

def test_input_is_dict_raises():
    # Should raise TypeError for dict input
    with pytest.raises(TypeError):
        funcA({'number': 5})

def test_input_is_tuple_raises():
    # Should raise TypeError for tuple input
    with pytest.raises(TypeError):
        funcA((5,))

# --- Determinism Test ---

def test_determinism():
    # Multiple calls with same input should yield same output
    for n in [0, 1, 10, 100, 1000]:
        codeflash_output = funcA(n)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

import pytest  # used for our unit tests
from workload import funcA

# unit tests

# --------------------------
# 1. Basic Test Cases
# --------------------------

def test_funcA_zero():
    # Test with number = 0 (should return empty string)
    codeflash_output = funcA(0) # 2.22μs -> 1.18μs (88.2% faster)

def test_funcA_one():
    # Test with number = 1 (should return "0")
    codeflash_output = funcA(1) # 2.40μs -> 1.07μs (124% faster)

def test_funcA_small_number():
    # Test with number = 5 (should return "0 1 2 3 4")
    codeflash_output = funcA(5) # 2.75μs -> 1.01μs (171% faster)

def test_funcA_typical_number():
    # Test with number = 10
    expected = " ".join(str(i) for i in range(10))
    codeflash_output = funcA(10) # 2.50μs -> 932ns (169% faster)

# --------------------------
# 2. Edge Test Cases
# --------------------------

def test_funcA_negative_number():
    # Test with negative number (should return empty string)
    codeflash_output = funcA(-3) # 1.91μs -> 1.01μs (89.0% faster)

def test_funcA_large_number_cap():
    # Test with number > 1000 (should cap at 1000)
    codeflash_output = funcA(1500); result = codeflash_output # 77.9μs -> 1.16μs (6602% faster)
    expected = " ".join(str(i) for i in range(1000))

def test_funcA_exactly_1000():
    # Test with number = 1000 (boundary case)
    codeflash_output = funcA(1000); result = codeflash_output # 77.0μs -> 1.13μs (6706% faster)
    expected = " ".join(str(i) for i in range(1000))

def test_funcA_float_input():
    # Test with float input (should raise TypeError)
    with pytest.raises(TypeError):
        funcA(5.5)

def test_funcA_string_input():
    # Test with string input (should raise TypeError)
    with pytest.raises(TypeError):
        funcA("10")

def test_funcA_none_input():
    # Test with None input (should raise TypeError)
    with pytest.raises(TypeError):
        funcA(None)

def test_funcA_boolean_input():
    # Test with boolean input (should treat True as 1, False as 0)
    codeflash_output = funcA(True) # 2.88μs -> 1.35μs (113% faster)
    codeflash_output = funcA(False) # 1.07μs -> 632ns (69.6% faster)

def test_funcA_large_negative():
    # Test with a very large negative number
    codeflash_output = funcA(-10000) # 2.08μs -> 1.24μs (67.8% faster)

# --------------------------
# 3. Large Scale Test Cases
# --------------------------

def test_funcA_near_upper_limit():
    # Test with number just below cap
    n = 999
    codeflash_output = funcA(n); result = codeflash_output # 78.0μs -> 1.12μs (6856% faster)
    expected = " ".join(str(i) for i in range(n))

def test_funcA_upper_limit():
    # Test with number at cap
    n = 1000
    codeflash_output = funcA(n); result = codeflash_output # 77.2μs -> 1.16μs (6536% faster)
    expected = " ".join(str(i) for i in range(n))

def test_funcA_above_upper_limit():
    # Test with number above cap
    n = 1050
    codeflash_output = funcA(n); result = codeflash_output # 77.4μs -> 1.11μs (6863% faster)
    expected = " ".join(str(i) for i in range(1000))

def test_funcA_performance_large_input():
    # Test function doesn't hang or error with large input (performance)
    n = 1000
    codeflash_output = funcA(n); result = codeflash_output # 76.7μs -> 1.12μs (6734% faster)
    # Only check the beginning and end for correctness to avoid large assert strings
    split_result = result.split()

# --------------------------
# Additional Edge Cases
# --------------------------

def test_funcA_input_is_list():
    # Should raise TypeError if input is a list
    with pytest.raises(TypeError):
        funcA([10])

def test_funcA_input_is_dict():
    # Should raise TypeError if input is a dict
    with pytest.raises(TypeError):
        funcA({'number': 10})

def test_funcA_input_is_tuple():
    # Should raise TypeError if input is a tuple
    with pytest.raises(TypeError):
        funcA((10,))

def test_funcA_input_is_object():
    # Should raise TypeError if input is an object
    class Dummy: pass
    with pytest.raises(TypeError):
        funcA(Dummy())

def test_funcA_input_is_complex():
    # Should raise TypeError if input is a complex number
    with pytest.raises(TypeError):
        funcA(5 + 3j)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.